package handler

import (
	"oa-system/internal/api/request"
	"oa-system/internal/service"
	"oa-system/pkg/errors"
	"oa-system/pkg/response"
	"oa-system/pkg/utils"

	"github.com/gin-gonic/gin"
)

type UserHandler struct {
	userService service.UserService
}

func NewUserHandler(userService service.UserService) *UserHandler {
	return &UserHandler{
		userService: userService,
	}
}

// GetAllUsersWithRoles godoc
// @Summary 获取用户列表及其角色
// @Description 获取所有用户及其角色信息，支持分页、按部门过滤、邮箱和名字模糊搜索，以及按角色筛选
// @Tags 用户模块
// @Accept json
// @Produce json
// @Param page query int false "当前页码" default(1)
// @Param pageSize query int false "每页记录数量" default(10)
// @Param departmentID query int false "部门ID"
// @Param email query string false "邮箱模糊搜索"
// @Param name query string false "名字模糊搜索"
// @Param roles query string false "角色ID列表，用逗号分隔，如 '3,4'"
// @Success 200 {object} response.Response{data=response.PageData{list=[]model.User,total=int}}
// @Router /users [get]
func (h *UserHandler) GetAllUsersWithRoles(c *gin.Context) {
	var req request.UserListRequest
	if err := c.ShouldBindQuery(&req); err != nil {
		response.Error(c, errors.NewBadRequestError("无效的请求参数", err))
		return
	}

	if err := req.Validate(); err != nil {
		response.Error(c, errors.NewBadRequestError("参数验证失败", err))
		return
	}

	users, total, err := h.userService.GetAllUsersWithRoles(
		req.Page,
		req.PageSize,
		req.DepartmentID,
		req.Email,
		req.Name,
		req.RoleIDs,
	)
	if err != nil {
		response.Error(c, err)
		return
	}

	// 使用分页响应
	response.PageSuccess(c, users, total, req.Page, req.PageSize)
}

// CreateUser godoc
// @Summary 创建新用户
// @Description 创建一个新的用户，并关联角色
// @Tags 用户模块
// @Accept json
// @Produce json
// @Param user body request.CreateUserRequest true "用户信息"
// @Success 200 {object} response.Response{data=model.User} "返回创建的用户信息"
// @Router /users [post]
func (h *UserHandler) CreateUser(c *gin.Context) {
	var req request.CreateUserRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.Error(c, errors.NewBadRequestError("无效的请求参数", err))
		return
	}

	if err := req.Validate(); err != nil {
		response.Error(c, errors.NewBadRequestError("参数验证失败", err))
		return
	}

	user, err := h.userService.CreateUser(&req)
	if err != nil {
		response.Error(c, err)
		return
	}

	response.SuccessWithMessage(c, "用户创建成功", user)
}

// UpdateUser godoc
// @Summary 更新用户信息
// @Description 更新指定用户的信息
// @Tags 用户模块
// @Accept json
// @Produce json
// @Param id path uint true "用户ID"
// @Param user body request.UpdateUserRequest true "用户信息"
// @Success 200 {object} response.Response{data=model.User} "返回更新后的用户信息"
// @Router /users/{id} [put]
func (h *UserHandler) UpdateUser(c *gin.Context) {
	id, err := utils.ParseUintParam(c, "id")
	if err != nil {
		response.Error(c, errors.NewBadRequestError("无效的用户ID", err))
		return
	}

	var req request.UpdateUserRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.Error(c, errors.NewBadRequestError("无效的请求参数", err))
		return
	}

	user, err := h.userService.UpdateUser(id, &req)
	if err != nil {
		response.Error(c, err)
		return
	}

	response.SuccessWithMessage(c, "用户更新成功", user)
}

// DeleteUser godoc
// @Summary 删除用户
// @Description 删除指定用户
// @Tags 用户模块
// @Accept json
// @Produce json
// @Param id path uint true "用户ID"
// @Success 200 {object} response.Response "返回删除成功信息"
// @Router /users/{id} [delete]
func (h *UserHandler) DeleteUser(c *gin.Context) {
	id, err := utils.ParseUintParam(c, "id")
	if err != nil {
		response.Error(c, errors.NewBadRequestError("无效的用户ID", err))
		return
	}

	if err := h.userService.DeleteUser(id); err != nil {
		response.Error(c, err)
		return
	}

	response.SuccessWithMessage(c, "用户删除成功", nil)
}

// Login godoc
// @Summary 用户登录
// @Description 用户登录并获取token
// @Tags 用户模块
// @Accept json
// @Produce json
// @Param loginRequest body request.LoginRequest true "登录信息"
// @Success 200 {object} response.Response{data=map[string]interface{}} "返回token和用户信息"
// @Router /auth/login [post]
func (h *UserHandler) Login(c *gin.Context) {
	var req request.LoginRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.Error(c, errors.NewBadRequestError("无效的请求参数", err))
		return
	}

	if err := req.Validate(); err != nil {
		response.Error(c, errors.NewBadRequestError("参数验证失败", err))
		return
	}

	token, user, err := h.userService.Login(req.Email, req.Password)
	if err != nil {
		response.Error(c, err)
		return
	}

	response.Success(c, gin.H{
		"token": token,
		"user":  user,
	})
}
